home *** CD-ROM | disk | FTP | other *** search
/ Alles Voor Internet / Tout Pour Internet / alles voor internet.iso / MacInternet™ / Telnet / NCSA / tn3270 2.3d26 source / tn3270 / cdialog.c < prev    next >
Text File  |  1991-05-16  |  10KB  |  425 lines
  1. /*
  2.  *  tn3270 for the Macintosh Source Code
  3.  *  Brown University Computing and Information Services
  4.  *  Version 2.3d21, January 17, 1991
  5.  *  Copyright (c) 1988, 1989, 1990, 1991 by Brown University and by
  6.  *  Peter John DiCamillo.
  7.  *
  8.  *  Permission is granted to any individual or institution to use, copy,
  9.  *  or redistribute the binary version of this software and its
  10.  *  documentation provided this notice and the copyright notices are
  11.  *  retained.  Permission is granted to any individual or non-profit
  12.  *  institution to use, copy, modify, or redistribute the source files
  13.  *  of this software provided this notice and the copyright notices are
  14.  *  retained.  This software may not be distributed for profit, either
  15.  *  in original form or in derivative works, nor can the source be
  16.  *  distributed to other than an individual or a non-profit institution.
  17.  *  Any  individual or group interested in seeing and/or using these
  18.  *  source files but who are prevented from doing so by the above
  19.  *  constraints should contact Don Wolfe, Assistant Vice-President for
  20.  *  Computer Systems at Brown University, (401) 863-7250, for possible
  21.  *  software licensing of the source developed at Brown.
  22.  *
  23.  *  Brown University and Peter John DiCamillo make no representations
  24.  *  about the suitability of this software for any purpose.
  25.  *
  26.  *  BROWN UNIVERSITY AND PETER JOHN DICAMILLO GIVE NO WARRANTY, EITHER
  27.  *  EXPRESS OR IMPLIED, FOR THE PROGRAM AND/OR DOCUMENTATION PROVIDED,
  28.  *  INCLUDING, WITHOUT LIMITATION, WARRANTY OF MERCHANTABILITY AND
  29.  *  WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE.
  30.  *
  31.  */
  32.  
  33. #define __SEG__ 3270seg2
  34. #include "maclib.h"
  35. #include "termdef.h"
  36. #include "globals.h"
  37.  
  38. #define PICKERWIDTH 430
  39. #define PICKERHEIGHT 282
  40.  
  41. extern PaletteHandle myPalette;
  42. extern RGBColor realblack, realwhite;
  43. PaletteHandle dlgpalette;
  44. extern GDHandle bitmap_gdev;            /* gdev used for bitmaps */
  45.  
  46. pascal Boolean myGETCOLOR(where,prompt,inColor,outColor,SW)
  47.     unsigned long where;
  48.     Str255 *prompt;
  49.     RGBColor *inColor;
  50.     RGBColor *outColor;
  51.     short SW;
  52.     extern 0xA82E;
  53.  
  54. colordlg()
  55. {
  56. DialogPtr dlgptr;
  57. DialogPeek dStorage;
  58. WindowPtr behind;
  59. unsigned short (*filterProc) ();
  60. short gtype;
  61. Handle gitem, itmlist;
  62. Rect gbox, mybox, dlgbox;
  63. void (*myitem) ();
  64. short i;
  65. GrafPtr gp;
  66. short itemHit;
  67. short * itemHitPtr;
  68. pascal unsigned short DlgFilter();
  69. pascal void colorbox();
  70. RGBColor in, out, actual;
  71. char tbase, texact, tinvert;
  72. RGBColor twhite, tyellow, tpink, tturquoise, tgreen,
  73.          tred, tblue, tblack, tback, tstat;
  74. static RGBColor dwhite = DFLTWHITE;
  75. static RGBColor dyellow = DFLTYELLOW;
  76. static RGBColor dpink = DFLTPINK;
  77. static RGBColor dturquoise = DFLTTURQUOISE;
  78. static RGBColor dgreen = DFLTGREEN;
  79. static RGBColor dred = DFLTRED;
  80. static RGBColor dblue = DFLTBLUE;
  81. static RGBColor dblack = DFLTBLACK;
  82. static RGBColor dback = DFLTBACK;
  83. static RGBColor ctdpink = CTDFLTPINK;
  84. static RGBColor ctdturquoise = CTDFLTTURQUOISE;
  85. static RGBColor ctdblue = CTDFLTBLUE;
  86. static RGBColor ctdback = CTDFLTBACK;
  87.  
  88. RGBColor rgbtemp;
  89.  
  90. GDHandle currGD;
  91. PixMapHandle currPM;
  92. short scrhsize, scrvsize;
  93. short whsize, wvsize;
  94.  
  95. dStorage = 0;
  96. behind = (WindowPtr)-1;
  97. dlgbox.top = 16;
  98. dlgbox.left = 44;
  99. dlgbox.bottom = 326;
  100. dlgbox.right = 469;
  101. itmlist = GetResource('DITL', 268);
  102. if (itmlist == 0) return;
  103. HandToHand(&itmlist);
  104. if (itmlist == 0) return;
  105. dlgptr = NewCDialog(dStorage, &dlgbox, "Colors", 0, 3, behind,
  106.                     0, 0L, itmlist);
  107.  
  108. /* center the dialog on the current gDevice */
  109. if (myWindow != 0) {
  110.     gbox = (*bitmap_gdev)->gdRect;
  111.     }
  112. else {
  113.     currGD = GetMainDevice();
  114.     gbox = (*currGD)->gdRect;
  115.     }
  116. scrhsize = gbox.right - gbox.left;
  117. scrvsize = gbox.bottom - gbox.top;
  118. whsize = dlgptr->portRect.right-dlgptr->portRect.left;
  119. wvsize = dlgptr->portRect.bottom - dlgptr->portRect.top;
  120. MoveWindow(dlgptr, gbox.left + (scrhsize-whsize)/2, 
  121.                    gbox.top + (scrvsize-wvsize)/3, 0);
  122.  
  123.  
  124. dlgpalette = NewPalette(11, 0L, pmCourteous, 0);
  125. SetPalette(dlgptr, dlgpalette, true);
  126. fixcolors(dlgpalette);
  127. ActivatePalette(dlgptr);
  128.  
  129. /* define routine to draw user item */
  130. myitem = colorbox;
  131. for (i=5; i < 24; i+=2) {
  132.     GetDItem(dlgptr, i, >ype, &gitem, &mybox);
  133.     SetDItem(dlgptr, i, gtype, myitem, &mybox);
  134.     }
  135.  
  136. /* define check boxes */
  137. defcbox(dlgptr);
  138. arrowcursor();
  139. ShowWindow(dlgptr);
  140.  
  141. /* frame the default selection */
  142. GetDItem(dlgptr, 1, >ype, &gitem, &gbox);
  143. GetPort(&gp);
  144. SetPort(dlgptr);
  145. PenSize(3,3);
  146. InsetRect(&gbox, -4, -4);
  147. FrameRoundRect(&gbox, 16, 16);
  148. PenSize(1,1);
  149. SetPort(gp);
  150.  
  151. itemHit = 99;
  152. itemHitPtr = &itemHit;
  153. filterProc = DlgFilter;
  154.  
  155. /* copy current settings */
  156. tbase = cs.basecolor;
  157. texact = cs.exactcolor;
  158. tinvert = cs.invertbw;
  159. twhite = cs.usrwhite;
  160. tyellow = cs.usryellow;
  161. tpink = cs.usrpink;
  162. tturquoise = cs.usrturquoise;
  163. tgreen = cs.usrgreen;
  164. tred = cs.usrred;
  165. tblue = cs.usrblue;
  166. tblack = cs.usrblack;
  167. tback = cs.usrback;
  168. tstat = cs.usrstat;
  169.  
  170. while ((itemHit != 1) && (itemHit != 3)) {
  171.     ModalDialog(filterProc, itemHitPtr);
  172.     switch(itemHit) {
  173.         case 1:                /* OK */
  174.                 if (myWindow != 0) fixcolors(myPalette);
  175.                 break;
  176.         case 2:                /* Set Default */
  177.                 cs.usrwhite = dwhite;
  178.                 cs.usryellow = dyellow;
  179.                 cs.usrgreen = dgreen;
  180.                 cs.usrred = dred;
  181.                 cs.usrblack = dblack;
  182.                 if (cs.exactcolor) {
  183.                     cs.usrpink = dpink;
  184.                     cs.usrturquoise = dturquoise;
  185.                     cs.usrblue = dblue;
  186.                     cs.usrback = dback;
  187.                     cs.usrstat = dblue;
  188.                     }
  189.                 else {
  190.                     cs.usrpink = ctdpink;
  191.                     cs.usrturquoise = ctdturquoise;
  192.                     cs.usrblue = ctdblue;
  193.                     cs.usrback = ctdback;
  194.                     cs.usrstat = ctdblue;
  195.                     }
  196.                 if (!cs.exactcolor) {
  197.                     cs.exactcolor = 1;
  198.                     fixcolors(dlgpalette);
  199.                     ActivatePalette(dlgptr);
  200.                     cs.exactcolor = 0;
  201.                     }
  202.                 cs.basecolor = 0;
  203.                 cs.invertbw = 0;
  204.                 defcbox(dlgptr);
  205.                 fixcolors(dlgpalette);
  206.                 ActivatePalette(dlgptr);
  207.                 if (myWindow != 0) {
  208.                     GetEntryColor(dlgpalette, RGBback, &rgbtemp);
  209.                     GetPort(&gp);
  210.                     SetPort(WritePtr);
  211.                     if (textmap) setgdev();
  212.                     RGBBackColor(&rgbtemp);
  213.                     if (PictPtr != 0) {
  214.                         SetPort(PictPtr);
  215.                         RGBBackColor(&rgbtemp);
  216.                         }
  217.                     if (textmap) resetgdev();
  218.                     SetPort(gp);
  219.                     }
  220.                 updcolors(dlgptr);
  221.                 break;
  222.         case 3:                /* Cancel */
  223.                 cs.basecolor = tbase;
  224.                 cs.exactcolor = texact;
  225.                 cs.invertbw = tinvert;
  226.                 cs.usrwhite = twhite;
  227.                 cs.usryellow = tyellow;
  228.                 cs.usrpink = tpink;
  229.                 cs.usrturquoise = tturquoise;
  230.                 cs.usrgreen = tgreen;
  231.                 cs.usrred = tred;
  232.                 cs.usrblue = tblue;
  233.                 cs.usrblack = tblack;
  234.                 cs.usrback = tback;
  235.                 cs.usrstat = tstat;
  236.                 fixcolors(dlgpalette);
  237.                 ActivatePalette(dlgptr);
  238.                 if (myWindow != 0) {
  239.                     GetEntryColor(dlgpalette, RGBback, &rgbtemp);
  240.                     GetPort(&gp);
  241.                     SetPort(WritePtr);
  242.                     if (textmap) setgdev();
  243.                     RGBBackColor(&rgbtemp);
  244.                     if (PictPtr != 0) {
  245.                         SetPort(PictPtr);
  246.                         RGBBackColor(&rgbtemp);
  247.                         }
  248.                     if (textmap) resetgdev();
  249.                     SetPort(gp);
  250.                     }
  251.                 break;
  252.         case 5:            /* white */
  253.         case 6:
  254.                 getclr(dlgptr, "white", &cs.usrwhite);
  255.                 break;
  256.         case 7:            /* yellow */
  257.         case 8:
  258.                 getclr(dlgptr, "yellow", &cs.usryellow);
  259.                 break;
  260.         case 9:            /* turquoise */
  261.         case 10:
  262.                 getclr(dlgptr, "turquoise", &cs.usrturquoise);
  263.                 break;
  264.         case 11:        /* green */
  265.         case 12:
  266.                 getclr(dlgptr, "green", &cs.usrgreen);
  267.                 break;
  268.         case 13:        /* pink */
  269.         case 14:
  270.                 getclr(dlgptr, "pink", &cs.usrpink);
  271.                 break;
  272.         case 15:        /* red */
  273.         case 16:
  274.                 getclr(dlgptr, "red", &cs.usrred);
  275.                 break;
  276.         case 17:        /* blue */
  277.         case 18:
  278.                 getclr(dlgptr, "blue", &cs.usrblue);
  279.                 break;
  280.         case 19:        /* black */
  281.         case 20:
  282.                 getclr(dlgptr, "black", &cs.usrblack);
  283.                 break;
  284.         case 21:        /* background */
  285.         case 22:
  286.                 getclr(dlgptr, "bkground", &cs.usrback);
  287.                 GetEntryColor(dlgpalette, RGBback, &rgbtemp);
  288.                 GetPort(&gp);
  289.                 if (myWindow != 0) {
  290.                     SetPort(WritePtr);
  291.                     if (textmap) setgdev();
  292.                     RGBBackColor(&rgbtemp);
  293.                     if (textmap) resetgdev();
  294.                     }
  295.                 actualcolor(&rgbtemp, &actual);
  296.                 if (actual == realwhite) {
  297.                     cs.invertbw = 1;
  298.                     defcbox(dlgptr);
  299.                     }
  300.                 else if (actual == realblack) {
  301.                     cs.invertbw = 0;
  302.                     defcbox(dlgptr);
  303.                     }
  304.                 if (PictPtr != 0) {
  305.                     if (textmap) setgdev();
  306.                     SetPort(PictPtr);
  307.                     RGBBackColor(&rgbtemp);
  308.                     if (textmap) resetgdev();
  309.                     }
  310.                 SetPort(gp);
  311.                 break;
  312.         case 23:        /* status line */
  313.         case 24:
  314.                 getclr(dlgptr, "status", &cs.usrstat);
  315.                 break;
  316.         case 25:        /* base color */
  317.                 cs.basecolor ^= 1;
  318.                 defcbox(dlgptr);
  319.                 break;
  320.         case 26:        /* exact color */
  321.                 cs.exactcolor ^= 1;
  322.                 fixcolors(dlgpalette);
  323.                 ActivatePalette(dlgptr);
  324.                 updcolors(dlgptr);
  325.                 defcbox(dlgptr);
  326.                 break;
  327.         case 27:        /* invert black and white */
  328.                 cs.invertbw ^= 1;
  329.                 defcbox(dlgptr);
  330.                 break;
  331.         default:
  332.                 break;
  333.         }
  334.     }
  335. DisposDialog(dlgptr);
  336. }
  337.  
  338. getclr(dlgptr, cname, cin)
  339. DialogPtr dlgptr;
  340. char * cname;
  341. RGBColor *cin;
  342. {
  343. GrafPtr gp;
  344. Point where;
  345. short result;
  346. short gtype;
  347. Handle gitem;
  348. Rect gbox;
  349. char prompt[48];
  350. RGBColor cout;
  351. GDHandle currGD;
  352. PixMapHandle currPM;
  353. short scrhsize, scrvsize;
  354.  
  355. strcpy(prompt, "Select color for ");
  356. strcat(prompt, cname);
  357. strcat(prompt, ":");
  358. GetPort(&gp);
  359. if (myWindow != 0) {
  360.     SetPort(myWindow);
  361.     }
  362.  
  363. /* center color picker on current gDevice */
  364. if (myWindow != 0) {
  365.     gbox = (*bitmap_gdev)->gdRect;
  366.     }
  367. else {
  368.     currGD = GetMainDevice();
  369.     gbox = (*currGD)->gdRect;
  370.     }
  371. scrhsize = gbox.right - gbox.left;
  372. scrvsize = gbox.bottom - gbox.top;
  373. where.h = gbox.left + (scrhsize-PICKERWIDTH)/2;
  374. where.v = gbox.top + (scrvsize-PICKERHEIGHT)/3;
  375.  
  376. ctop(prompt);
  377. result = GETCOLOR(where, prompt, cin, &cout);
  378. ptoc(prompt);
  379. if (result) {
  380.     *cin = cout;
  381.     fixcolors(dlgpalette);
  382.     ActivatePalette(dlgptr);
  383.     updcolors(dlgptr);
  384.     }
  385. /* frame the default selection again */
  386. GetDItem(dlgptr, 1, >ype, &gitem, &gbox);
  387. SetPort(dlgptr);
  388. PenSize(3,3);
  389. InsetRect(&gbox, -4, -4);
  390. FrameRoundRect(&gbox, 16, 16);
  391. PenSize(1,1);
  392. SetPort(gp);
  393. }
  394.  
  395. defcbox(dlgptr)
  396. DialogPtr dlgptr;
  397. {
  398. short gtype;
  399. Handle gitem;
  400. Rect gbox;
  401.  
  402. GetDItem(dlgptr, 25, >ype, &gitem, &gbox);
  403. SetCtlValue(gitem, cs.basecolor);
  404. GetDItem(dlgptr, 26, >ype, &gitem, &gbox);
  405. SetCtlValue(gitem, cs.exactcolor);
  406. GetDItem(dlgptr, 27, >ype, &gitem, &gbox);
  407. SetCtlValue(gitem, cs.invertbw);
  408. }
  409.  
  410. updcolors(dlgptr)
  411. DialogPtr dlgptr;
  412. {
  413. Rect crect;
  414. GrafPtr gp;
  415.  
  416. crect.top = 5;
  417. crect.left = 5;
  418. crect.bottom = 295;
  419. crect.right = 100;
  420. GetPort(&gp);
  421. SetPort(dlgptr);
  422. InvalRect(&crect);
  423. SetPort(gp);
  424. }
  425.